import { FormConfig } from '../types'
import { generateValidationScript } from '../utils/validation'
import { FieldRendererFactory } from '../components'
import { safeJSONStringify, validateCodeSnippet, createDecodeFunction, createObjectDecodeFunction } from '../utils/htmlUtils'

/**
 * 安全地准备上下文数据
 */
function prepareContextData(context?: any): string {
  if (!context) {
    return 'null'
  }

  try {
    // 确定清理模式
    const sanitizeMode = context.sanitizeMode || 'moderate'

    // 使用智能清理功能
    const codeValidation = validateCodeSnippet(context.codeSnippet || '', sanitizeMode)

    // 记录清理结果
    if (codeValidation.cleaningLog?.isModified) {
      console.info('代码已自动清理:', {
        removed: codeValidation.cleaningLog.removedElements.length,
        warnings: codeValidation.cleaningLog.warnings,
        info: codeValidation.cleaningLog.info
      })
    }

    // 只对真正的安全问题发出警告
    if (codeValidation.warnings.length > 0) {
      console.warn('代码安全处理:', codeValidation.warnings)
    }

    const contextObj = {
      filePath: (context.filePath || '').toString().trim(),
      lineRange: (context.lineRange || '').toString().trim(),
      codeSnippet: codeValidation.sanitized, // 使用清理后的代码
      originalCodeLength: (context.codeSnippet || '').length,
      sanitizedCodeLength: codeValidation.sanitized.length,
      isCodeValid: codeValidation.isValid,
      wasModified: codeValidation.cleaningLog?.isModified || false,
      cleaningInfo: codeValidation.cleaningLog?.info || [],
      warnings: codeValidation.warnings
    }

    // 使用新的安全JSON序列化（支持Base64编码）
    return safeJSONStringify(contextObj)
  } catch (error) {
    console.error('准备上下文数据失败:', error)
    return 'null'
  }
}

/**
 * 安全地准备字段数据
 */
function prepareFieldsData(fields: any[]): string {
  try {
    const fieldsObj = fields.reduce((acc, field) => {
      try {
        if (field.type === 'tags') {
          acc[field.id] = Array.isArray(field.value) ? field.value : []
        } else {
          acc[field.id] = typeof field.value === 'string' ? field.value : ''
        }
      } catch (error) {
        console.error('处理字段数据失败:', field.id, error)
        acc[field.id] = ''
      }
      return acc
    }, {} as Record<string, any>)

    return safeJSONStringify(fieldsObj)
  } catch (error) {
    console.error('准备字段数据失败:', error)
    return '{}'
  }
}

/**
 * 生成主要脚本内容
 */
function generateScriptContent(fieldsData: string, contextData: string, fieldScripts: string, validationScript: string): string {
  return `
    // 全局错误处理
    window.addEventListener('error', function(event) {
      console.error('表单脚本错误:', event.error);
      log('发生错误: ' + event.error.message);
    });
    
    // 添加解码函数
    ${createDecodeFunction()}
    ${createObjectDecodeFunction()}
    
    // 安全地获取vscode API
    const vscode = (function() {
      try {
        return acquireVsCodeApi();
      } catch (error) {
        console.error('无法获取VSCode API:', error);
        // 返回mock对象以防止脚本崩溃
        return {
          postMessage: function(msg) {
            console.log('Mock postMessage:', msg);
          },
          setState: function(state) {
            console.log('Mock setState:', state);
          }
        };
      }
    })();
    
    // 安全地解析数据
    const contextData = (function() {
      try {
        const rawData = ${contextData};
        // 解码可能被编码的字符串
        return decodeObjectStrings(rawData);
      } catch (error) {
        console.error('解析上下文数据失败:', error);
        log('上下文数据解析失败');
        return null;
      }
    })();
    
    const initialData = (function() {
      try {
        const rawData = ${fieldsData};
        return decodeObjectStrings(rawData);
      } catch (error) {
        console.error('解析初始数据失败:', error);
        log('初始数据解析失败');
        return {};
      }
    })();
    
    // 显示处理信息（如果有）
    if (contextData) {
      if (contextData.wasModified) {
        log('✅ 代码片段已自动清理，移除了不安全的内容');
        if (contextData.cleaningInfo && contextData.cleaningInfo.length > 0) {
          contextData.cleaningInfo.forEach(info => log('🔧 清理信息: ' + info));
        }
      }
      
      if (contextData.warnings && contextData.warnings.length > 0) {
        contextData.warnings.forEach(warning => log('⚠️ 安全提示: ' + warning));
      }
      
      // 显示代码大小变化
      if (contextData.originalCodeLength !== contextData.sanitizedCodeLength) {
        log('📊 代码大小: ' + contextData.originalCodeLength + ' → ' + contextData.sanitizedCodeLength + ' 字符');
      }
    }
    
    // 安全地初始化表单数据
    try {
      Object.keys(initialData).forEach(fieldId => {
        try {
          const field = document.getElementById(fieldId);
          if (field) {
            const fieldValue = initialData[fieldId];
            if (Array.isArray(fieldValue)) {
              field.value = JSON.stringify(fieldValue);
            } else if (fieldValue !== null && fieldValue !== undefined) {
              field.value = String(fieldValue);
            }
          }
        } catch (error) {
          console.error('初始化字段失败:', fieldId, error);
        }
      });
      
      log('✅ 表单初始化完成，字段数量: ' + Object.keys(initialData).length);
    } catch (error) {
      console.error('表单初始化失败:', error);
      log('❌ 表单初始化失败: ' + error.message);
    }
    
    // 字段初始化脚本（包装在try-catch中）
    try {
      ${fieldScripts}
    } catch (error) {
      console.error('字段脚本执行失败:', error);
      log('❌ 字段脚本执行失败: ' + error.message);
    }
    
    // 安全的表单提交处理
    try {
      const form = document.getElementById('genericForm');
      if (form) {
        form.addEventListener('submit', function(e) {
          e.preventDefault();
          handleFormSubmit();
        });
      }
    } catch (error) {
      console.error('表单事件绑定失败:', error);
    }
    
    function handleFormSubmit() {
      try {
        log('📤 表单提交事件触发');
        
        const formData = {};
        let isValid = true;
        
        // 安全地执行验证脚本
        try {
          ${validationScript}
        } catch (error) {
          console.error('表单验证失败:', error);
          log('❌ 表单验证失败: ' + error.message);
          isValid = false;
        }
        
        if (isValid) {
          // 安全地添加上下文数据
          if (contextData) {
            try {
              Object.assign(formData, {
                filePath: contextData.filePath || '',
                lineRange: contextData.lineRange || '',
                codeSnippet: contextData.codeSnippet || '' // 已经是清理后的安全代码
              });
            } catch (error) {
              console.error('添加上下文数据失败:', error);
            }
          }
          
          log('📤 准备发送数据，代码片段长度: ' + (formData.codeSnippet ? formData.codeSnippet.length : 0) + ' 字符');
          
          vscode.postMessage({
            command: 'submit',
            data: formData
          });
        } else {
          log('❌ 表单验证失败');
          alert('请填写所有必填字段');
        }
      } catch (error) {
        console.error('表单提交处理失败:', error);
        log('❌ 表单提交失败: ' + error.message);
        alert('提交失败，请重试');
      }
    }
    
    // 安全的取消按钮处理
    try {
      const cancelBtn = document.getElementById('cancelBtn');
      if (cancelBtn) {
        cancelBtn.addEventListener('click', function() {
          try {
            log('❌ 取消按钮点击');
            vscode.postMessage({
              command: 'cancel'
            });
          } catch (error) {
            console.error('取消操作失败:', error);
          }
        });
      }
    } catch (error) {
      console.error('取消按钮事件绑定失败:', error);
    }
    
    // 安全的自动聚焦
    try {
      const firstField = document.querySelector('.form-input');
      if (firstField && typeof firstField.focus === 'function') {
        firstField.focus();
        log('🎯 自动聚焦到第一个输入框');
      }
    } catch (error) {
      console.error('自动聚焦失败:', error);
    }
  `
}

/**
 * 生成降级安全脚本
 * 当主脚本生成失败时使用
 */
function generateFallbackScript(): string {
  return `
    console.error('表单脚本生成失败，使用降级模式');
    
    try {
      const vscode = acquireVsCodeApi();
      
      // 最基本的取消功能
      const cancelBtn = document.getElementById('cancelBtn');
      if (cancelBtn) {
        cancelBtn.addEventListener('click', function() {
          vscode.postMessage({ command: 'cancel' });
        });
      }
      
      // 显示错误信息
      const container = document.querySelector('.form-container');
      if (container) {
        const errorDiv = document.createElement('div');
        errorDiv.style.color = 'red';
        errorDiv.style.padding = '10px';
        errorDiv.style.marginBottom = '10px';
        errorDiv.textContent = '表单初始化失败，请关闭后重试';
        container.insertBefore(errorDiv, container.firstChild);
      }
    } catch (error) {
      console.error('降级脚本也失败了:', error);
    }
  `
}

/**
 * 安全地生成表单脚本
 * 包含完整的错误处理和安全验证
 */
export function generateFormScript(config: FormConfig): string {
  try {
    const factory = new FieldRendererFactory()

    // 生成字段初始化脚本
    const fieldScripts = config.fields
      .map(field => {
        try {
          return factory.getFieldScript(field)
        } catch (error) {
          console.error('生成字段脚本失败:', field.id, error)
          return ''
        }
      })
      .filter(script => script)
      .join('\n')

    // 安全地准备初始数据
    const fieldsData = prepareFieldsData(config.fields)

    // 安全地处理上下文数据
    const contextData = prepareContextData(config.context)

    // 生成验证脚本
    const validationScript = generateValidationScript(config.fields)

    return generateScriptContent(fieldsData, contextData, fieldScripts, validationScript)
  } catch (error) {
    console.error('生成表单脚本失败:', error)
    // 返回最小化的安全脚本
    return generateFallbackScript()
  }
}
